<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    
</body>
</html>
<script>
    //把喜欢的事做到极致，便成了价值.
    //21 04 02 夜 补充知识点
    //21 04 20 夜 美团没事补充数组方法 

    /*数组是js中常用数据集合 内置方法有很多 */
    //1 创建数组 
      //1使用数组字面量表示法
        var arr4 = [];    //创建有个空数组
        var arr5 = [20]   //创建有个包含1项数据为20的数组
        var arr6 = ["王","八","蛋"] //创建有个包含3个字符串的数组
    //2 使用Array构造函数
        //无参构造
        arr1 = new Array();  //创建有个空数组
        //带参构造
        //如果传入一个数字参数 则代表创建一个初始长度为指定数值的空数组 
        arr2 = new Array(20); //创建一个包含20项的数组 
        console.log(arr2)     //length 20 
        //如果传入一个非数值参数&参数个数>1 则表示创建一个包含指定元素的数组 
        var arr3 = new Array("你","我","她")  //创建一个包含3个字符串的数组

    //3 Array.of 方法创建数据(es6的)
        //Array.of 创建一个包含所有传入参数的数组 而不管参数的数量&类型 
        let arr = Array.of(1,2);
        console.log(arr.length) //2 
        let arr1 = Array.of(3);
        console.log(arr1.length) //1
        console.log(arr[0])      //3
        //用于生成一个数组对象 主要是用来弥补Array() 不足   
        let res = Array.of(1,2,3)
        console.log(res)         //[1,2,3]
                //Array.of()方法： 
        //把一堆文本或者变量转换成数组
        //标准的JSON数组格式 跟普通的JSON对比是在最后多了一个length属性。
        //只要是这种特殊的json格式都可以轻松使用ES6的语法转变成数组
        let  json = {
                '0': 'jspang',
                '1': '技术胖',
                '2': '大胖逼逼叨',
                length:3
            }   
            console.log(json)   // {0: "jspang", 1: "技术胖", 2: "大胖逼逼叨", length: 3}
            let arr=Array.from(json);
            console.log(arr)    // ["jspang", "技术胖", "大胖逼逼叨"]
        // str & num 都可以的
        let arr =Array.of(3,4,5,6);
        console.log(arr);        //[3, 4, 5, 6]
        console.log(eval(arr))   //[3, 4, 5, 6]
        let arr =Array.of('常','东东','收购腾讯');
        console.log(arr);      // ["常", "东东", "收购腾讯"]
        console.log(eval(arr)) // ["常", "东东", "收购腾讯"]
    
    

    //entires(), keys(), values() es6 
        //这三个方法都是循环数组 搭配for...of使用  
        //区别是 keys是对键名的循环   values是对键值的循环   entires是对键值对儿的循环 
        for(let index of [a,b].keys()){
            console.log(index);
        }    
        // 0 1 
        for(let elem of [a,b].values()){
            console.log(elem)
        }
        // a b 
        for(let [index,elem] of [a,b].()){
            console.log(index,elem)
        }
        //0 "a"
        //1 "b"

    //flat 和 faltMap()  es6 
        //flat方法会按照一个可指定的深度递归循环数组 并将所有元素与循环到的子元素中的元素合并为一个新数组返回 
        //这个方法 返回一个新数组 对原数组么有影响 
        //参数 指定要提取嵌套数组的结构深度 默认值1 
        const arr1 = [0,1,2,[3,4]]
        console.log(arr1.flat());  //0,1,2,3,4
        const arr2 = [0,1,2[[[3,4]]]]
        console.log(arr2.flat(2)); //0,1,2,[3,4]
        //使用 Infinity 可展开任意深度的嵌套数组 ----- 传的参数为Infinity 
        var arr4 = [1,2[3,4,[5,6,[7,8,[9,10]]]]]
        console.log(arr4.flat(Infinity))  //[1,2,3,4,5,6,7,8,9,10]
        //注意扁平化数组 如果原数据有空位flat()方法会跳过这个空位
        var arr4 = [1,2,,4,5]
        arr.flat();
        //[1,2,3,4]
        //flatMap()方法 对原数组的每个成员执行一个函数 ==Array.prottype.map() 然后对返回值组成的数组执行flat()方法
        //该方法灰灰一个新数组 不改变原数组 
        //相当于 [[2,4],[3,6],[4,8],].flat()
        [2,3,4].flatMap((x)=>[x,x*2])
        //[2,4,3,6,4,8]


    //copyWithin() es6 
        //copyWithin()方法 用于从数组的指定位置拷贝元素到数组的另一个指定位置中  
        //该方法会改变现有数组  
        //将数组的前两个数组复制到数组的最后两个位置 
        let arr = [1,2,3,arr,5]
        arr.copyWithin(3,0)               //从下标3开始粘贴 从下标0开始复制 
        console.log(arr) //[1,2,3,1,2]
        //注意默认情况下 copyWithin()方法 总会一直复制到数组末尾 
        //提供一个参数来限制到底有多少元素 会被覆盖 三个参数指定复制停止的位置 (不包含位置本身)
        let arr = [1,2,3,arr,5,9,17]
        //从下标3 位置开始粘贴
        //从下标0 位置开始复制
        //遇到下标3 时停止就
        arr.copyWithin(3,0,3)
        console.log(arr) //1,2,3,1,2,3,17       

    //reduceRight() 和 reduce 
        //两个方法都会实现循环数组的所有项(即累加器) 然后构建一个最终返回的值  
        //reduce()方法从数组的第一项开始 逐个循环到最后  
        //reduceRight()则从数组的最后一项开始 向前遍历到第一项    
        //4个参数   1前一个值 2当前值 3项的索引 4数组对象即本身 
        var values = [1,2,3,4,5];
        var sum = valuse.reduceRight(function(prev,cur,index,array){
            return prve + cur;
        },10)   //注意数组一开始加了一个初始值10  可以不设置默认 
        console.log(sum); //25 

    //includes() es7       
        //includes()方法 用来判断一个数组是否包含一个指定的值 如果是返回true 否则false 
        //两个参数 1参(必填)即需要查找的元素 2参(可选)开始查找元素的位置  
        const array1 = [22,3,31,12,arr]
        const includes = array1.includes(31);
        console.log(includes) //true 
        const includes1 = array1.includes(31,3) //从索引3开始查找31是否存在
        console.log(includes1); //false
        //注意 includes使用===运算符 来进行值的比较 仅一个例外  NaN 会被认为与自身相等 
        let values =[1,Nan,2];
        console.log(valuse.indexOf(NaN)); //-1
        console.log(values.includes(NaN)) //true


    //some() 和 every() 
        //every() 判断数组中的每一项都是否满足条件 只有所有的项都满足条件 才会返回true 
        //some()  判断数组中是否存在满足条件的项  只要有一项满足条件 就会返回true     
        //some—demo
        var arr = [1,2,3,4,5];
        var arr2 = arr.some(function(x){
            return x<3;
        })
        console.log(arr2)  //true

        var arr3 = arr.some(function(x){
            return x<1;
        })
        console.log(arr3)   //false 

        //every-demo 
        var arr = [1,2,3,4,5];
        var arr2 = arr.every((x)=>x<10);
        console.log(arr2)   //true 
        var arr3 = arr.every((x)=>x<3);
        console.log(arr3);   //false



    //fill() es6的   
        //fill()方法  能够使用特定值填充数组中的一个或多个元素 
        //当只是用一个参数时 该方法会用该参数的值填充整个数组      
        let arr = [1,2,3,cc,5];
        arr.fill(1);
        console.log(arr) //[1,1,1,1,1];
        //注意如果不想改变数组中的所有元素 只是想改变其中的一部分 
        //那么可以使用可选的起始位置参数 & 结束位置参数 (不包括结束位置的那个元素)
        //3个参数 填充数值变量  开始填充的位置   填充到的位置  (不包括结束位置的那个元素)
        let arr = [1,2,3,4,5];
        arr.fill(1,2);
        console.log(arr) //[1,2,1,1,1]

        let arr = [1,2,3,4,5,6,7,8];
        arr.fill("常",2,4);
        console.log(arr)  //[1, 2, "常", "常", 5, 6, 7, 8]  
                          //从第二个位置到第四个位置 用常来填充 

        


        //咋样取出数组对象某个属性值 
        let arr = [
            {"companyPK":1,
             "pk":1,
            "role":"角色一"},
            {"companyPK":2,
             "pk":2,
            "role":"角色二"},
            {"companyPK":3,
             "pk":3,
            "role":"角色三"},
            ]
            let newArr = arr.map(item=>item.role)
            let roles = newArr.join(",") //角色1 角色2 角色3    


        //按需取值取值  
           let arr = [  {"age":11},
                        {"age":12},
                        {"age":13},
                        {"age":14}  
                     ]
            let newArr = [];
            arr.filter((item)=>{
                console.log(item.age != 11);
                if(item.age != 11 == true){
                    newArr.push(item.age)
                }
            })
            console.log(newArr);

 
        //find()实例方法 
        //实例方法 就是并不是以Array对象开始的 则需要必须有一个已存在的数组 然后使用方法 
        //find方法从数组中查找 在find方法中我们要查找 一个匿名函数 函数需传三个参数 
        //   value 表示当前查找的值  index表示当前查找的数组下标  arr 当前的数组 
        //在函数中 如果找到符合条件的数组元素就进行return 停止查找  
        let arr=[1,2,3,4,5,6,7,8,9];
        console.log(arr.find(function(value,index,arr){
            return value > 5;
        }))
        //  6 
        // 说明找到了符合条件的值 并且返回了 如果没有找不到 会显示undefined 



        //数组的便利 
        //for ... of循环 
        //这种形式 比Es5的for循环更简单而且高效 
        let arr=['jspang','技术胖','大胖逼逼叨']
        for (let item of arr){
            console.log(item); 
        }
        //即每一项i   'jspang','技术胖','大胖逼逼叨'
        //for…of数组索引 有时候开发中是需要数组的索引的，那我们可以使用下面的代码输出数组索引。
        let arr=['jspang','技术胖','大胖逼逼叨']
        for (let index of arr.keys()){
            console.log(index);
        }
        //0 1 2 
        //取键 .values()  取键值对 .entries()




        //in的用法  
        //in是用来判断对象或者数组中是否存在某个值的
        //对象判断
        let obj={
            a:'jspang', 
            b:'技术胖'
        }
        console.log('a' in obj);  //true
        //代码输出了5，但是数组中其实全是空值，这就是一个坑啊。
        let arr=[,,,,,];
        console.log(arr.length); //5   
        //那用ES6的in就可以解决这个问题。   //这里的零指的是数组的下标位置是是否为空 
        let arr=[,,,,,];
        console.log(0 in arr); //false
        let arr1=['jspang','技术胖'];
        console.log(0 in arr1);  // true  



        //数组 转字符串 
        let arr=['jspang','技术胖','前端教程'];
        //console.log(arr.join('|'));  //jspang|技术胖|前端教程   (可以自定义分隔符) 加了一些间隔，开发中很有用处。
        console.log(arr.toString());   //jspang,技术胖,前端教程   转换时只是是用逗号隔开了











        






























































    





        
















        


        






</script>